/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package futbol.tacticas.concursantes.aitkiar.aitutil;

import futbol.tacticas.SituacionJugadores;
import java.awt.Point;

/**
 *
 * @author aitkiar
 */
public class Utils
{
    public static Point ultimaBola;
    
    public static double distancia( Point origen, Point destino )
    {
        return Math.sqrt( ( origen.x - destino.x ) * (origen.x - destino.x ) +
            ( origen.y - destino.y ) * ( origen.y - destino.y ));
    }
    
    public static boolean disparo( Point posicion, SituacionJugadores sj )
    {
        Point bola = sj.getBola();
        return distancia( posicion, bola ) <= 10;
    }
    
    /** Calculamos la siguiente posición de la bola basándonos en lo que ha avanzado sabiendo que cada
     * turno avanza un punto menos.
     * 
     * Si no tenemos información de donde estaba la bola en el turno anterior devolvemos la posición
     * actual.
     * @param sj
     * @return
     */
    public static Point siguientePosicionBola( SituacionJugadores sj )
    {
        int x;
        int y;
        int d;
        Point bola;
        
        if ( ultimaBola == null )
        {
            return sj.getBola();
        }
        bola = sj.getBola();
        d = ( int )Math.round( distancia( sj.getBola(), ultimaBola ));
        if ( d ==  0)
        {
            return sj.getBola();
        }

        x = ( d * ( 2 * bola.x - ultimaBola.x ) -bola.x + ultimaBola.x )/ d;
        y = ( d * ( 2 * bola.y - ultimaBola.y ) -bola.y + ultimaBola.y )/ d;
        return new Point( x, y);
    }
    
    /** Obtiene la posición a partir de la que un jugador puede interceptar la bola. Un jugadpr
     * puede interceptar la bola cuando la velocidad de la misma es 14 o menor.
     * 
     * @return
     */
    public static Point posicionTrayectoriaBola( SituacionJugadores sj )
    {
        return posicionTrayectoriaBola( sj, 14 );
    }
    
    /** Obtiene la posicion en la que estará la bola, suponiendo que no será desviada cuando alcance
     *  la velocidad límite.
     * 
     * @param sj
     * @param velocidadLimite
     * @return
     */
    public static Point posicionTrayectoriaBola( SituacionJugadores sj, int velocidadLimite )
    {
        int distanciaTotal = 0;
        int velocidad;
        int d;
        int x;
        int y;
        Point bola = sj.getBola();
        
        if ( ultimaBola == null )
        {
            return bola;
        }
            
        velocidad =  ( int )Math.round( distancia( ultimaBola, bola ));
        d = velocidad;
        
        if ( velocidad < velocidadLimite )
        {
            return bola;
        }
        
        while ( velocidad >= velocidadLimite )
        {
            distanciaTotal += velocidad;
            velocidad --;
        }
        
        x = d * ( bola.x - ultimaBola.x) / distanciaTotal + ultimaBola.x;
        y = d * ( bola.y - ultimaBola.y) / distanciaTotal + ultimaBola.y;
        return new Point( x, y );
    }
    
    public static boolean avanzaBola( SituacionJugadores sj )
    {
        Point bola = sj.getBola();
        Point siguiente = siguientePosicionBola( sj );
        return siguiente.x - bola.x > 0;
    }
    
    public static int getMasCercano( SituacionJugadores sj, Point punto )
    {
        Point[] jugadores = sj.getMisJugadores();
        int masCercano = 1;
        double distanciaMasCercano = 1000;
        
        for ( int i = 0; i < 11; i ++ )
        {
            if ( distanciaMasCercano > distancia( jugadores[i], punto ))
            {
                distanciaMasCercano = distancia( jugadores[i], punto );
                masCercano = i;
            }
        }
        return masCercano;
    }
    
    public static Point getContrarioMasCercano( SituacionJugadores sj, int jugador )
    {
        return sj.getContrario()[sj.getContrarioMasCerca( jugador )];
    }
    
    public static int heuristicaMarca( Point punto, int cota, SituacionJugadores sj )
    {
        Point contrarios[] = sj.getContrario();
        int suma = 0;
        int cuenta = 0;
        for ( int i = 0; i < 11; i ++ )
        {
            if ( distancia( punto, contrarios[i]) < cota )
            {
                suma += cota - distancia( punto, contrarios[i] );
                cuenta ++;
            }
            
        }
        if (  cuenta == 0 )
        {
            return 0;
        }
        return suma / cuenta;
    }

    public static int getDistanciaDisparo( int fuerza )
    {
        int distancia = 0;
        for ( int i = fuerza * 3; i > 14; i -- )
        {
            distancia += i;
        }

        return distancia;
    }
}
